/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package proy01.beans;

import java.util.Date;

/**
 *
 * @author malaga
 */
public class Persona implements Comparable<Persona> {
    
    protected int id;
    protected String nombre;
    protected Date fecNac;

    public Persona() {
    }

    public int getId() {
        return id;
    }

    public String getNombre() {
        return nombre;
    }

    public Date getFecNac() {
        return fecNac;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public void setFecNac(Date fecNac) {
        this.fecNac = fecNac;
    }
    
    /*
     * El mètodo compareTo es el ùnico mètodo de la interfaz Comparable. fìjate
     * arriba en la declaraciòn de la clase dice "implements Comparable<Persona>"
     * Una interfaz agrega propiedades a las clases que la implementan.
     * 
     * TIP: generalmente se leen asi -> Clase es Interfaz
     *      en este caso serìa "Persona es Comparable"
     * 
     * Segùn la documentaciòn, este mètodo
     * Devuelve
     * - negativo : si this es menor que per
     * - cero     : si this es igual que per
     * - positivo : si this es mayor que per
     * 
     * this este objeto y 
     * per es el paràmetro. Si no entiendes bien, haz una prueba con Strings
     * 
     * String menor = "aaa";
     * String mayor = "bbb";
     * int resutado = -10000;
     * 
     * resultado = menor.compareTo(mayor);
     * 
     */
    @Override
    public int compareTo(Persona per) {
        
        int resultInt = 0;
        
        int resultID = 0;
        int resultNombre = 0;
        int resultFecNac = 0;
        
        int perID        = per.getId();
        String perNombre = per.getNombre();
        Date perFecNac   = per.getFecNac();

        /*
         * Id es un tipo de dato bàsico, por lo que no tiene mètodos.
         * Para ese caso, usamos las Wrapped Classes. Existen wrapped classes
         * para cada tipo de dato bàsico.
         * 
         * Una wrapped class es una Clase que "envuelve" un tipo de dato bàsico
         * para poder ejecutar operaciones CON ellas o EN ellas.
         */

        // Para poder utilizar el mètodo compare en con un entero
        Integer wrappedInt = new Integer(this.id);
        
        /* Obtenemos los resultados de las comparaciones de cada campo que
         * consideremos.
         * 
         * Las clases Integer, String y Date vienen con el método "compareTo"
         * implementado (son "Comparable")
         */
        resultID     = wrappedInt.compareTo(perID);
        resultNombre = this.nombre.compareToIgnoreCase(perNombre);
        resultFecNac = this.fecNac.compareTo(perFecNac);
        
        /*
         * Se programa la lògica de còmo se va a considerar un Objeto Persona
         * mayor o menor que otra.
         */
        
        // El orden natural serà por fecha de nacimiento
        
        //En caso de que tengan la misma fecha de nacimiento
        if(resultFecNac == 0) {
            
            // En caso de que tengan el mismo nombre
            if(resultNombre == 0) {
                
                // En caso de que tengan el mismo nombre, se ordena por el ID
                resultInt = resultID;
            } else {
                resultInt = resultNombre;
            }
            
         } else {
            resultInt = resultFecNac;
        }
        
        return resultInt;
    }

    @Override
    public String toString() {
        return " " + this.id + "\t" + nombre + "\t" + fecNac;
    }

}
